package HighConcurrency.JUC;

import java.util.Comparator;
import java.util.concurrent.*;

public class BlockingQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> bq=new ArrayBlockingQueue<>(5);
        //ArrayBlockingQueue底层依靠数组实现，容量指定之后不能变

        BlockingQueue<String> bq1=new LinkedBlockingQueue<>();
        //链表，几乎完全一致，底层实现不同，可以指定容量，可以不指定
        //指定容量之后，容量不变，不制定则容量为int最大值Integer.MAX_VALUE，一般认为是无限大


        Comparator<Student> comparator=new Comparator<Student>() {//指定优先级排序
            public int compare(Student o1, Student o2) {
                return o1.age-o2.age;//升序排序
            }
        };
        PriorityBlockingQueue<Student> bq2=new PriorityBlockingQueue<>(11, comparator);
        //默认容量11，可以指定容量，底层依靠数组
        //默认升序排序，添加的元素必须实现comparable接口，否则抛出异常ClassCastException
        // 可以覆盖compareTo方法来实现目的
        for (Student student:bq2)//增强for循环遍历，本质是一种迭代器，不保证排序
        {
            System.out.println(student);
        }

        SynchronousQueue<String> bq3=new SynchronousQueue<>();//同步队列
        // 容量为1，不存储元素，每次只能有一个元素，必须等待被消费，否则不能添加元素，否则会阻塞


        BlockingDeque<String> bq4=new LinkedBlockingDeque<>();
        //双端队列，可以添加和移除元素，可以指定容量，可以不指定
        bq4.addFirst("a");
        bq4.addLast("b");
        bq4.removeFirst();
        bq4.removeLast();
        //双端队列

        //在队列没满的情况下，区别不大
        //队列已满的情况下
        bq.add("a");//会抛出异常IllegalStateException，非阻塞类型
        bq.offer("b");//返回false,非阻塞
        bq.put("c");//阻塞类型，会永久阻塞

        bq.offer("f",5, TimeUnit.SECONDS);//定时阻塞

        bq.remove();//会抛出异常NoSuchElementException，非阻塞类型
        bq.poll();//返回null,非阻塞
        bq.take();//永久阻塞
        bq.poll(5,TimeUnit.SECONDS);//定时阻塞


    }
}
class Student implements Comparable<Student>{
    private String name;
     int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int compareTo(Student o) {
        return this.age-o.age;
    }
}
